home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / gnu / gpp-1_42.lha / g++-1.42.0 / print-tree.c < prev    next >
C/C++ Source or Header  |  1991-10-19  |  16KB  |  682 lines
  1. /* Prints out tree in human readable form - GNU C-compiler
  2.    Copyright (C) 1987 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. #include "config.h"
  22. #include "tree.h"
  23. #include <stdio.h>
  24.  
  25. extern char **tree_code_name;
  26.  
  27. extern char *mode_name[];
  28.  
  29. extern char spaces[];
  30.  
  31. #define MIN(x,y) ((x < y) ? x : y)
  32.  
  33. static FILE *outfile;
  34.  
  35. extern int tree_node_counter;
  36.  
  37. /* markvec[i] is 1 if node number i has been seen already.  */
  38.  
  39. static char *markvec;
  40.  
  41. static void dump ();
  42. void dump_tree ();
  43.  
  44. void
  45. debug_dump_tree (root)
  46.      tree root;
  47. {
  48.   dump_tree (stderr, root);
  49. }
  50.  
  51. /* Don't know, why they have different names in C and c++ (hgs) */
  52. void
  53. debug_tree (root)
  54.      tree root;
  55. {
  56.   dump_tree (stderr, root);
  57. }
  58.  
  59. void
  60. dump_tree (outf, root)
  61.      FILE *outf;
  62.      tree root;
  63. {
  64.   markvec = (char *) alloca (tree_node_counter + 1);
  65.   bzero (markvec, tree_node_counter + 1);
  66.   outfile = outf;
  67.   dump (root, 0);
  68.   fflush (outf);
  69. }
  70.  
  71. static
  72. void
  73. wruid (node)
  74.      tree node;
  75. {
  76.  
  77.   if (node == NULL)
  78.     fputs ("<>", outfile);
  79.   else {
  80.     fprintf (outfile, "%1d", TREE_UID (node));
  81.   }
  82. }
  83.  
  84. static 
  85. void
  86. part (title, node)
  87.      char title[];
  88.      tree node;
  89. {
  90.   fprintf (outfile, " %s = ", title);
  91.   wruid (node);
  92.   putc (';', outfile);
  93. }
  94.  
  95. /* Similar to `part' but prefix with @ if value is not constant
  96.    and print the constant value if it is constant.  */
  97. static
  98. void
  99. cpart (title, ct, punct)
  100.      char *title;
  101.      tree ct;
  102.      char punct;
  103. {
  104.   fprintf (outfile, " %s = ", title);
  105.   if (ct == NULL)
  106.     fputs ("<>", outfile);
  107.   else
  108.     {
  109.       if (!TREE_LITERAL (ct))
  110.     {
  111.       putc ('@', outfile);
  112.       wruid (ct);
  113.     }
  114.       else
  115.     fprintf (outfile, "%ld", TREE_INT_CST_LOW (ct));
  116.     }
  117.   putc (punct, outfile);
  118. }
  119.  
  120. static void
  121. walk (node, leaf, indent)
  122.      tree node;
  123.      tree leaf;
  124.      int indent;
  125. {
  126.   if (node != NULL
  127.       /* Don't walk any global nodes reached from local nodes!
  128.      The global nodes will be dumped at the end, all together.
  129.      Also don't mention a FUNCTION_DECL node that is marked local
  130.      since it was fully described when it was dumped locally.  */
  131.       && (TREE_CODE (node) != FUNCTION_DECL
  132.       || TREE_PERMANENT (node))
  133.       && (TREE_PERMANENT (leaf) == TREE_PERMANENT (node)))
  134.     dump (node, indent+1);
  135. }
  136.  
  137. static void
  138. cwalk (s, leaf, indent)
  139.      tree s;
  140.      tree leaf;
  141.      int indent;
  142. {
  143.   if (s != NULL) 
  144.     if (!TREE_LITERAL (s))
  145.       walk (s, leaf, indent);
  146. }
  147.  
  148. static void
  149. prtypeinfo (node)
  150.      register tree node;
  151. {
  152.   int first;
  153.   
  154.   part ("type", TREE_TYPE (node));
  155.   first = 1;
  156.   fputs (" [", outfile);
  157.   if (TREE_EXTERNAL (node))
  158.     {
  159.       if (!first) putc (' ', outfile);
  160.       fputs ("external", outfile);
  161.       first = 0;
  162.     }
  163.   if (TREE_PUBLIC (node))
  164.     {
  165.       if (!first) putc (' ', outfile);
  166.       fputs ("public", outfile);
  167.       first = 0;
  168.     }
  169.   if (TREE_STATIC (node))
  170.     {
  171.       if (!first) putc (' ', outfile);
  172.       fputs ("static", outfile);
  173.       first = 0;
  174.     }
  175.   if (TREE_VOLATILE (node))
  176.     {
  177.       if (!first) putc (' ', outfile);
  178.       fputs ("volatile", outfile);
  179.       first = 0;
  180.     }
  181.   if (TREE_PACKED (node))
  182.     {
  183.       if (!first) putc (' ', outfile);
  184.       fputs ("packed", outfile);
  185.       first = 0;
  186.     }
  187.   if (TREE_READONLY (node))
  188.     {
  189.       if (!first) putc (' ', outfile);
  190.       fputs ("readonly", outfile);
  191.       first = 0;
  192.     }
  193.   if (TREE_LITERAL (node))
  194.     {
  195.       if (!first) putc (' ', outfile);
  196.       fputs ("literal", outfile);
  197.       first = 0;
  198.     }
  199.   if (TREE_NONLOCAL (node))
  200.     {
  201.       if (!first) putc (' ', outfile);
  202.       fputs ("nonlocal", outfile);
  203.       first = 0;
  204.     }
  205.   if (TREE_ADDRESSABLE (node))
  206.     {
  207.       if (!first) putc (' ', outfile);
  208.       fputs ("addressable", outfile);
  209.       first = 0;
  210.     }
  211.   if (TREE_REGDECL (node))
  212.     {
  213.       if (!first) putc (' ', outfile);
  214.       fputs ("regdecl", outfile);
  215.       first = 0;
  216.     }
  217.   if (TREE_THIS_VOLATILE (node))
  218.     {
  219.       if (!first) putc (' ', outfile);
  220.       fputs ("this_vol", outfile);
  221.       first = 0;
  222.     }
  223.   if (TREE_UNSIGNED (node))
  224.     {
  225.       if (!first) putc (' ', outfile);
  226.       fputs ("unsigned", outfile);
  227.       first = 0;
  228.     }
  229.   if (TREE_ASM_WRITTEN (node))
  230.     {
  231.       if (!first) putc (' ', outfile);
  232.       fputs ("asm_written", outfile);
  233.       first = 0;
  234.     }
  235.   if (TREE_INLINE (node))
  236.     {
  237.       if (!first) putc (' ', outfile);
  238.       fputs ("inline", outfile);
  239.       first = 0;
  240.     }
  241.   if (TREE_USED (node))
  242.     {
  243.       if (!first) putc (' ', outfile);
  244.       fputs ("used", outfile);
  245.       first = 0;
  246.     }
  247.   if (TREE_PERMANENT (node))
  248.     {
  249.       if (!first) putc (' ', outfile);
  250.       fputs ("permanent", outfile);
  251.       first = 0;
  252.     }
  253.   if (TREE_LANG_FLAG_1 (node))
  254.     {
  255.       if (!first) putc (' ', outfile);
  256.       fputs ("lang_flag_1", outfile);
  257.       first = 0;
  258.     }
  259.   if (TREE_LANG_FLAG_2 (node))
  260.     {
  261.       if (!first) putc (' ', outfile);
  262.       fputs ("lang_flag_2", outfile);
  263.       first = 0;
  264.     }
  265.   if (TREE_LANG_FLAG_3 (node))
  266.     {
  267.       if (!first) putc (' ', outfile);
  268.       fputs ("lang_flag_3", outfile);
  269.       first = 0;
  270.     }
  271.   if (TREE_LANG_FLAG_4 (node))
  272.     {
  273.       if (!first) putc (' ', outfile);
  274.       fputs ("lang_flag_4", outfile);
  275.       first = 0;
  276.     }
  277.   fputs ("] ", outfile);
  278. }
  279.  
  280. static void
  281. prdeclmodeinfo (node)
  282.      tree node;
  283. {
  284.   register enum machine_mode mode = DECL_MODE (node);
  285.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  286.  
  287.   cpart ("size", DECL_SIZE (node), '*');
  288.   fprintf (outfile, "%d;", DECL_SIZE_UNIT (node));
  289.  
  290.   fprintf (outfile, " alignment = %1d;", DECL_ALIGN (node));
  291. }
  292.  
  293. static void
  294. prtypemodeinfo (node)
  295.      tree node;
  296. {
  297.   register enum machine_mode mode = TYPE_MODE (node);
  298.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  299.  
  300.   cpart ("size", TYPE_SIZE (node), '*');
  301.   fprintf (outfile, "%d;", TYPE_SIZE_UNIT (node));
  302.  
  303.   fprintf (outfile, " alignment = %1d;", TYPE_ALIGN (node));
  304. }
  305.  
  306. static void
  307. skip (indent)
  308.      int indent;
  309. {
  310.   putc ('\n',outfile);
  311.   fputs (spaces + (strlen (spaces) - (12 + MIN (40,(indent+1)*2))), outfile);
  312. }
  313.  
  314. /* Output a description of the tree node NODE
  315.    if its description has not been output already.  */
  316.  
  317. static 
  318. void
  319. dump (node, indent)
  320.      tree node;
  321.      int indent;
  322. {
  323.   register enum tree_code code = TREE_CODE (node);
  324.   register int i;
  325.   register int len, first_rtl;
  326.   int nochain = 0;
  327.  
  328.   if (markvec[TREE_UID (node)])
  329.     return;
  330.   markvec[TREE_UID (node)] = 1;
  331.  
  332.   fputs ("   ", outfile);
  333.   fprintf (outfile, "%5d", TREE_UID (node));
  334.   fputs (spaces + (strlen (spaces) - MIN (40, (indent+1)*2)), outfile);
  335.   fputs (tree_code_name[(int) code], outfile);
  336.  
  337.   switch (*tree_code_type[(int) code])
  338.     {
  339.     case 'd':
  340.       fputs (" name = ", outfile);
  341.       if (DECL_NAME (node) == NULL)
  342.     fputs ("<>;", outfile);
  343.       else
  344.     fprintf (outfile, "%s;",
  345.          IDENTIFIER_POINTER (DECL_NAME (node)));
  346.       if (code != PARM_DECL)
  347.     fprintf (outfile, " at %s line %d;",
  348.          DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
  349.       skip (indent);
  350.       prdeclmodeinfo (node);
  351.       prtypeinfo (node);
  352. #ifdef PRINT_LANG_DECL
  353.       print_lang_decl (node);
  354. #endif
  355.       skip (indent);
  356.       fprintf (outfile, " offset = %1d;", DECL_OFFSET (node));
  357.       if (DECL_VOFFSET (node) != NULL)
  358.     {
  359.       fputs ("voffset = ", outfile);
  360.       wruid (DECL_VOFFSET (node));
  361.       fprintf (outfile, "*%1d;", DECL_VOFFSET_UNIT (node));
  362.     }
  363.       part ("context", DECL_CONTEXT (node));
  364.       if (code == FUNCTION_DECL)
  365.     {
  366.       if (DECL_ARGUMENTS (node) || DECL_RESULT (node)
  367.           || DECL_INITIAL (node))
  368.         {
  369.           skip (indent);
  370.           part ("arguments", DECL_ARGUMENTS (node));
  371.           part ("result", DECL_RESULT (node));
  372.           if ((int) (DECL_INITIAL (node)) == 1)
  373.         fprintf (outfile, " initial = const 1;");
  374.           else
  375.         part ("initial", DECL_INITIAL (node));
  376.         }
  377.     }
  378.       else if (DECL_INITIAL (node))
  379.     {
  380.       if ((int) (DECL_INITIAL (node)) == 1)
  381.         fprintf (outfile, " initial = const 1;");
  382.       else
  383.         part ("initial", DECL_INITIAL (node));
  384.     }
  385. #ifdef PRINT_LANG_DECL
  386.       walk_lang_decl (node);
  387. #endif
  388.       part ("chain", TREE_CHAIN (node));
  389.       /* A Decl's chain contents is not part of the decl.  */
  390.       nochain = 1;
  391.       fputc ('\n', outfile);
  392.       cwalk (DECL_SIZE (node), node, indent);
  393.       walk (TREE_TYPE (node), node, indent);
  394.       walk (DECL_VOFFSET (node), node, indent);
  395.       walk (DECL_CONTEXT (node), node, indent);
  396.       if (code == FUNCTION_DECL)
  397.     {
  398.       walk (DECL_ARGUMENTS (node), node, indent);
  399.       walk (DECL_RESULT (node), node, indent);
  400.     }
  401.       if ((int) (DECL_INITIAL (node)) != 1)
  402.     walk (DECL_INITIAL (node), node, indent);
  403.       break;
  404.  
  405.     case 't':
  406.       prtypemodeinfo (node);
  407.       prtypeinfo (node);
  408. #ifdef PRINT_LANG_TYPE
  409.       print_lang_type (node);
  410. #endif
  411.       skip (indent);
  412.       part ("pointers_to_this", TYPE_POINTER_TO (node));
  413.       if (code == ARRAY_TYPE || code == SET_TYPE)
  414.     {
  415.       part ("domain", TYPE_DOMAIN (node));
  416.       cpart ("separation", TYPE_SEP (node), '*');
  417.       fprintf (outfile, "%d;", TYPE_SEP_UNIT (node));
  418.     }
  419.       else if (code == INTEGER_TYPE)
  420.     {
  421.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  422.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  423.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  424.     }
  425.       else if (code == ENUMERAL_TYPE)
  426.     {
  427.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  428.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  429.       part ("values", TYPE_VALUES (node));
  430.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  431.     }
  432.       else if (code == REAL_TYPE)
  433.     {
  434.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  435.     }
  436.       else if (code == RECORD_TYPE
  437.            || code == UNION_TYPE)
  438.     {
  439.       part ("fields", TYPE_FIELDS (node));
  440.     }
  441.       else if (code == FUNCTION_TYPE)
  442.     {
  443.       part ("arg_types", TYPE_ARG_TYPES (node));
  444.     }
  445.       else if (code == METHOD_TYPE)
  446.     {
  447.       part ("arg_types", TYPE_ARG_TYPES (node));
  448.     }
  449. #ifdef PRINT_LANG_TYPE
  450.       walk_lang_type (node);
  451. #endif
  452.       part ("chain", TREE_CHAIN (node));
  453.       /* A type's chain's contents are not printed because the chain of types
  454.      is not part of the meaning of any particular type.  */
  455.       nochain = 1;
  456.       fputc ('\n', outfile);
  457.       cwalk (TYPE_SIZE (node), node, indent);
  458.       walk (TREE_TYPE (node), node, indent);
  459.       walk (TYPE_VALUES (node), node, indent);
  460.       walk (TYPE_SEP (node), node, indent);
  461.       walk (TYPE_POINTER_TO (node), node, indent);
  462.       walk (TYPE_REFERENCE_TO (node), node, indent);
  463.       break;
  464.  
  465.     case 'e':
  466.     case 'r':
  467.       prtypeinfo (node);
  468.       fputs (" ops =", outfile);
  469.       first_rtl = len = tree_code_length[(int) code];
  470.       /* These kinds of nodes contain rtx's, not trees,
  471.      after a certain point.  Print the rtx's as rtx's.  */
  472.       switch (code)
  473.     {
  474.     case SAVE_EXPR:
  475.       first_rtl = 1;
  476.       break;
  477.     case CALL_EXPR:
  478.       first_rtl = 2;
  479.       break;
  480.     case METHOD_CALL_EXPR:
  481.       first_rtl = 3;
  482.       break;
  483.     case WITH_CLEANUP_EXPR:
  484.       /* Should be defined to be 2.  */
  485.       first_rtl = 1;
  486.       break;
  487.     case RTL_EXPR:
  488.       first_rtl = 0;
  489.     }
  490.       for (i = 0; i < len; i++)
  491.     {
  492.       if (i >= first_rtl)
  493.         {
  494.           skip (indent);
  495.           if (TREE_OPERAND (node, i))
  496.         print_rtl (outfile, TREE_OPERAND (node, i));
  497.           else
  498.         fprintf (outfile, "(nil)");
  499.           fprintf (outfile, "\n");
  500.         }
  501.       else
  502.         {
  503.           fputs (" ", outfile);
  504.           wruid (TREE_OPERAND (node, i));
  505.           fputs (";", outfile);
  506.         }
  507.     }
  508.       part ("chain", TREE_CHAIN (node));
  509.       fputc ('\n', outfile);
  510.       walk (TREE_TYPE (node), node, indent);
  511.       for (i = 0; i < len && i < first_rtl; i++)
  512.     walk (TREE_OPERAND (node, i), node, indent);
  513.       break;
  514.  
  515.     case 's':
  516.       prtypeinfo (node);
  517.       fprintf (outfile, " at %s line %d;",
  518.            STMT_SOURCE_FILE (node), STMT_SOURCE_LINE (node));
  519.       switch (TREE_CODE (node))
  520.     {
  521.     case IF_STMT:
  522.       part ("cond", STMT_COND (node));
  523.       part ("then", STMT_THEN (node));
  524.       part ("else", STMT_ELSE (node));
  525.       break;
  526.  
  527.     case LET_STMT:
  528.     case WITH_STMT:
  529.       part ("vars", STMT_VARS (node));
  530.       part ("tags", STMT_TYPE_TAGS (node));
  531.       part ("supercontext", STMT_SUPERCONTEXT (node));
  532.       part ("bind_size", STMT_BIND_SIZE (node));
  533.       part ("body", STMT_BODY (node));
  534.       part ("subblocks", STMT_SUBBLOCKS (node));
  535.       break;
  536.  
  537.     case CASE_STMT:
  538.       part ("case_index", STMT_CASE_INDEX (node));
  539.       part ("case_list", STMT_CASE_LIST (node));
  540.       break;
  541.  
  542.     default:
  543.       part ("body", STMT_BODY (node));
  544.       break;
  545.     }
  546.       part ("chain", TREE_CHAIN (node));
  547.       fputc ('\n', outfile);
  548.       walk (TREE_TYPE (node), node, indent);
  549.       switch (TREE_CODE (node))
  550.     {
  551.     case IF_STMT:
  552.       walk (STMT_COND (node), node, indent);
  553.       walk (STMT_THEN (node), node, indent);
  554.       walk (STMT_ELSE (node), node, indent);
  555.       break;
  556.  
  557.     case LET_STMT:
  558.     case WITH_STMT:
  559.       walk (STMT_VARS (node), node, indent);
  560.       walk (STMT_TYPE_TAGS (node), node, indent);
  561.       walk (STMT_SUPERCONTEXT (node), node, indent);
  562.       walk (STMT_BIND_SIZE (node), node, indent);
  563.       walk (STMT_BODY (node), node, indent);
  564.       walk (STMT_SUBBLOCKS (node), node, indent);
  565.       break;
  566.  
  567.     case CASE_STMT:
  568.       walk (STMT_CASE_INDEX (node), node, indent);
  569.       walk (STMT_CASE_LIST (node), node, indent);
  570.       break;
  571.  
  572.     default:
  573.       walk (STMT_BODY (node), node, indent);
  574.       break;
  575.     }
  576.       break;
  577.  
  578.     case 'c':
  579.       switch (code)
  580.     {
  581.     case INTEGER_CST:
  582.       if (TREE_INT_CST_HIGH (node) == 0)
  583.         fprintf (outfile, " = %1u;", TREE_INT_CST_LOW (node));
  584.       else if (TREE_INT_CST_HIGH (node) == -1
  585.            && TREE_INT_CST_LOW (node) != 0)
  586.         fprintf (outfile, " = -%1u;", -TREE_INT_CST_LOW (node));
  587.       else
  588.         fprintf (outfile, " = 0x%x%08x;",
  589.              TREE_INT_CST_HIGH (node),
  590.              TREE_INT_CST_LOW (node));
  591.       break;
  592.  
  593.     case REAL_CST:
  594. #ifndef REAL_IS_NOT_DOUBLE
  595.       fprintf (outfile, " = %e;", TREE_REAL_CST (node));
  596. #else
  597.       {
  598.         int i;
  599.         char *p = (char *) &TREE_REAL_CST (node);
  600.         fprintf (outfile, " = 0x");
  601.         for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
  602.           fprintf (outfile, "%02x", *p++);
  603.         fprintf (outfile, ";");
  604.       }
  605. #endif /* REAL_IS_NOT_DOUBLE */
  606.       break;
  607.  
  608.     case COMPLEX_CST:
  609.       part ("realpart", TREE_REALPART (node));
  610.       part ("imagpart", TREE_IMAGPART (node));
  611.       walk (TREE_REALPART (node), node, indent);
  612.       walk (TREE_IMAGPART (node), node, indent);
  613.       break;
  614.  
  615.     case STRING_CST:
  616.       fprintf (outfile, " = \"%s\";", TREE_STRING_POINTER (node));
  617.     }
  618.       prtypeinfo (node);
  619.       part ("chain", TREE_CHAIN (node));
  620.       fputc ('\n', outfile);
  621.       walk (TREE_TYPE (node), node, indent);
  622.       break;
  623.  
  624.     case 'x':
  625.       if (code == IDENTIFIER_NODE)
  626.     {
  627.       fprintf (outfile, " = %s;\n", IDENTIFIER_POINTER (node));
  628.       nochain = 1;
  629.     }
  630.       else if (code == TREE_LIST)
  631.     {
  632.       prtypeinfo (node);
  633.       part ("purpose", TREE_PURPOSE (node));
  634.       part ("value", TREE_VALUE (node));
  635.       part ("chain", TREE_CHAIN (node));
  636.       fputc ('\n', outfile);
  637.       walk (TREE_TYPE (node), node, indent);
  638.       walk (TREE_PURPOSE (node), node, indent);
  639.       walk (TREE_VALUE (node), node, indent);
  640.     }
  641.       else if (code == TREE_VEC)
  642.     {
  643.       prtypeinfo (node);
  644.       len = TREE_VEC_LENGTH (node);
  645.       fprintf (outfile, "length = %d\n", len);
  646.       for (i = 0; i < len; i++)
  647.         {
  648.           fputs (" ", outfile);
  649.           wruid (TREE_VEC_ELT (node, i));
  650.           fputs (";", outfile);
  651.         }
  652.       part ("chain", TREE_CHAIN (node));
  653.       fputc ('\n', outfile);
  654.       walk (TREE_TYPE (node), node, indent);
  655.       for (i = 0; i < len; i++)
  656.         walk (TREE_VEC_ELT (node, i), node, indent);
  657.     }
  658.       else if (code == OP_IDENTIFIER)
  659.     {
  660.       prtypeinfo (node);
  661.       part ("op1", TREE_PURPOSE (node));
  662.       part ("op2", TREE_VALUE (node));
  663.       part ("chain", TREE_CHAIN (node));
  664.       fputc ('\n', outfile);
  665.       walk (TREE_TYPE (node), node, indent);
  666.       walk (TREE_PURPOSE (node), node, indent);
  667.       walk (TREE_VALUE (node), node, indent);
  668.     }
  669.       else if (code == ERROR_MARK)
  670.     fputc ('\n', outfile);
  671.       else abort ();
  672.  
  673.       break;
  674.  
  675.     default:
  676.       abort ();
  677.     } /* switch */
  678.  
  679.   if (TREE_CHAIN (node) != NULL && ! nochain)
  680.     dump (TREE_CHAIN (node), indent);
  681. }
  682.